{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 利用lstm进行生成莫言小说——keras实现方法\n",
    "**注：该项目提供了keras建模的示例，除模型构建外，其余部分相同**\n",
    "## 1. 项目背景\n",
    "这个项目是建立一个能够自动生成一片文章的深度学习模型，我们可以通过给出钱几个字就自动生成一篇文章的模型。\n",
    "\n",
    "## 2. 项目数据\n",
    "项目数据使用了莫言小说《生死疲劳》，内容如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "　　我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的 酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的 回声。我身受酷刑而绝不改悔，挣得了一个硬汉子的名声。我知道许多鬼卒对我暗中钦佩，我也知道阎王 老子对我不胜厌烦。为了让我认罪服输，他们使出了地狱酷刑中最歹毒的一招，将我扔到沸腾的油锅里， 翻来覆去，像炸(又鸟)一样炸了半个时辰，痛苦之状，难以言表。鬼卒还用叉子把我叉起来，高高举着， 一步步走上通往大殿的台阶。两边的鬼卒嘬口吹哨，如同成群的吸血蝙蝠鸣叫。我的身体滴油淅沥，落在 台阶上，冒出一簇簇黄烟……鬼卒小心翼翼地将我安放在阎罗殿前的青石板上，跪下向阎王报告：“大王 ，炸好了。”\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# ========读取原始数据========\n",
    "with open('data.txt', 'r', encoding='utf-8') as f:\n",
    "    data = f.readlines()\n",
    "print(data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 数据处理\n",
    "### 3.1数据清洗\n",
    "**首先需要将括号里的内容删除掉。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "　　我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的 酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的 回声。我身受酷刑而绝不改悔，挣得了一个硬汉子的名声。我知道许多鬼卒对我暗中钦佩，我也知道阎王 老子对我不胜厌烦。为了让我认罪服输，他们使出了地狱酷刑中最歹毒的一招，将我扔到沸腾的油锅里， 翻来覆去，像炸一样炸了半个时辰，痛苦之状，难以言表。鬼卒还用叉子把我叉起来，高高举着， 一步步走上通往大殿的台阶。两边的鬼卒嘬口吹哨，如同成群的吸血蝙蝠鸣叫。我的身体滴油淅沥，落在 台阶上，冒出一簇簇黄烟……鬼卒小心翼翼地将我安放在阎罗殿前的青石板上，跪下向阎王报告：“大王 ，炸好了。”\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "# 生成一个正则，负责找'()'包含的内容\n",
    "pattern = re.compile(r'\\(.*\\)')\n",
    "# 将其替换为空\n",
    "data = [pattern.sub('', lines) for lines in data]\n",
    "print(data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "　　我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的 酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的 回声。我身受酷刑而绝不改悔，挣得了一个硬汉子的名声。我知道许多鬼卒对我暗中钦佩，我也知道阎王 老子对我不胜厌烦。为了让我认罪服输，他们使出了地狱酷刑中最歹毒的一招，将我扔到沸腾的油锅里， 翻来覆去，像炸一样炸了半个时辰，痛苦之状，难以言表。鬼卒还用叉子把我叉起来，高高举着， 一步步走上通往大殿的台阶。两边的鬼卒嘬口吹哨，如同成群的吸血蝙蝠鸣叫。我的身体滴油淅沥，落在 台阶上，冒出一簇簇黄烟。鬼卒小心翼翼地将我安放在阎罗殿前的青石板上，跪下向阎王报告：“大王 ，炸好了。”\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 将.....替换为句号\n",
    "data = [line.replace('……', '。') for line in data if len(line) > 1]\n",
    "print(data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的回声。我身受酷\n"
     ]
    }
   ],
   "source": [
    "# ==============判断char是否是乱码===================\n",
    "def is_uchar(uchar):\n",
    "    \"\"\"判断一个unicode是否是汉字\"\"\"\n",
    "    if uchar >= u'\\u4e00' and uchar<=u'\\u9fa5':\n",
    "            return True\n",
    "    \"\"\"判断一个unicode是否是数字\"\"\"\n",
    "    if uchar >= u'\\u0030' and uchar<=u'\\u0039':\n",
    "            return True       \n",
    "    \"\"\"判断一个unicode是否是英文字母\"\"\"\n",
    "    if (uchar >= u'\\u0041' and uchar<=u'\\u005a') or (uchar >= u'\\u0061' and uchar<=u'\\u007a'):\n",
    "            return True\n",
    "    if uchar in ('，','。','：','？','“','”','！','；','、','《','》','——'):\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "# 将每行的list合成一个长字符串\n",
    "data = ''.join(data)\n",
    "data = [char for char in data if is_uchar(char)]\n",
    "data = ''.join(data)\n",
    "print(data[:100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 生成字典\n",
    "我们需要将汉字映射为能够输入到模型中的数字信息，就需要建立一个映射关系，需要生成汉字和数字互相映射的字典。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "字典长度: 3892\n"
     ]
    }
   ],
   "source": [
    "# =====生成字典=====\n",
    "vocab = set(data)\n",
    "id2char = list(vocab)\n",
    "char2id = {c:i for i,c in enumerate(vocab)}\n",
    "\n",
    "print('字典长度:', len(vocab))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 转换输入数据格式\n",
    "建立字典后，将文本数据映射为数字数据形式，并整理为矩阵格式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数字数据信息：\n",
      " [ 801 1153  901 2708  752 3693 1255 2756 1876  983 2434 1255  727 1255\n",
      "  413 2309  811 2192  295 1618 1469 1571 2228 2434 1248 1153   73 1204\n",
      " 1975  752  801  295 3086 2303  838 1284 1975 1956 1714  305 3231 1204\n",
      " 1411  214  595 2139 1153 2694 1815 2192 1281  479 3437 1034  752  801\n",
      " 1721    2 2757 2207 3174  920 2192  801 1153 2774  689 2747 3765 2943\n",
      "  759  752  855 3324 3733 2470 3109 2698 1889 1153 1281   35  559 1695\n",
      "  752 1004 2718  625 3417 3417 2900 2900 1153 3127 2774 2192  801  210\n",
      " 1956 2694]\n",
      "\n",
      "文本数据信息：\n",
      " 我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的回声。我身受酷\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# =====转换数据为数字格式======\n",
    "numdata = [char2id[char] for char in data]\n",
    "numdata = np.array(numdata)\n",
    "\n",
    "print('数字数据信息：\\n', numdata[:100])\n",
    "print('\\n文本数据信息：\\n', ''.join([id2char[i] for i in numdata[:100]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 设计数据生成器\n",
    "这篇文章有几十万个字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "377480\n"
     ]
    }
   ],
   "source": [
    "print(len(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input data: [ 801 1153  901 2708  752] \n",
      "output data: [1153  901 2708  752 3693]\n"
     ]
    }
   ],
   "source": [
    "# =======设计数据生成器=========\n",
    "def data_generator(data, batch_size, time_stpes):\n",
    "\tsamples_per_batch = batch_size * time_stpes\n",
    "\tbatch_nums = len(data) // samples_per_batch\n",
    "\tdata = data[:batch_nums*samples_per_batch]\n",
    "\tdata = data.reshape((batch_size, batch_nums, time_stpes))\n",
    "\tfor i in range(batch_nums):\n",
    "\t\tx = data[:, i, :]\n",
    "\t\ty = np.zeros_like(x)\n",
    "\t\ty[:, :-1] = x[:, 1:]\n",
    "\t\ttry:\n",
    "\t\t\ty[:, -1] = data[:, i+1, 0]\n",
    "\t\texcept:\n",
    "\t\t\ty[:, -1] = data[:, 0, 0]\n",
    "\t\tyield x, y\n",
    "\n",
    "# 打印输出数据\n",
    "data_batch = data_generator(numdata, 2, 5)\n",
    "x, y = next(data_batch)\n",
    "print('input data:', x[0], '\\noutput data:', y[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将y转化为onehot格式\n",
    "def onehot(y):\n",
    "\ty_onehot = np.zeros(shape=(y.shape[0], y.shape[1], VOCAB_SIZE))\n",
    "\tfor i in range(y.shape[0]):\n",
    "\t\tfor j in range(y.shape[1]):\n",
    "\t\t\ty_onehot[i][j][y[i][j]] = 1\n",
    "\treturn y_onehot\n",
    "print('y:', y)\n",
    "y = onehot(y)\n",
    "print('onehot:', y)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 模型选择与建模\n",
    "我们选择rnn来作为文本生成模型结构如下：\n",
    "![image.png](attachment:image.png)\n",
    "我们选择lstm来做为其中的隐藏层：\n",
    "![image.png](attachment:image.png)\n",
    "### 4.1 使用keras进行建模："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Model\n",
    "from keras.layers import Input, LSTM, Dense, Dropout, Embedding\n",
    "from keras import regularizers\n",
    "from keras.optimizers import Adam\n",
    "import numpy as np\n",
    "# ====================================搭建模型===================================\n",
    "class RNNModel():\n",
    "    \"\"\"docstring for RNNModel\"\"\"\n",
    "    def __init__(self, BATCH_SIZE, HIDDEN_SIZE, HIDDEN_LAYERS, VOCAB_SIZE):\n",
    "        inputs = Input(shape=(None,))\n",
    "        emb_inp = Embedding(output_dim=HIDDEN_SIZE, input_dim=VOCAB_SIZE, input_length=None)(inputs)\n",
    "        for i in range(HIDDEN_LAYERS):\n",
    "            emb_inp = LSTM(HIDDEN_SIZE, activation='relu', return_sequences=True, dropout=0.2)(emb_inp)\n",
    "        output = Dense(VOCAB_SIZE, activation='softmax', kernel_regularizer=regularizers.l2(0.01))(emb_inp)\n",
    "        model = Model(inputs=inputs, outputs=output)\n",
    "\n",
    "        # ============训练所需损失函数==========\n",
    "        opt = Adam(lr=0.003, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\n",
    "        model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "        model.summary()\n",
    "        self.model = model\n",
    "        \n",
    "    def train(self, x, y):\n",
    "        \n",
    "        self.model.fit(x, y)\n",
    "    \n",
    "    def test(self, x_initial):\n",
    "        x_test = x_initial\n",
    "        for i in range(100):\n",
    "            y_pre = self.model.predict(x_test)\n",
    "            index = np.argmax(y_pre, 2)\n",
    "            x_test = np.concatenate((x_initial, index), axis=1)\n",
    "        x_test = np.reshape(x_test, (-1,))\n",
    "        print(''.join([id2char[i] for i in x_test]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 定义训练参数及模型参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "VOCAB_SIZE = len(id2char)\n",
    "EPOCHS = 50\n",
    "BATCH_SIZE = 8\n",
    "TIME_STEPS = 100\n",
    "BATCH_NUMS = len(numdata) // (BATCH_SIZE * TIME_STEPS)\n",
    "HIDDEN_SIZE = 512\n",
    "HIDDEN_LAYERS = 2\n",
    "MAX_GRAD_NORM = 1\n",
    "learning_rate = 0.003"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 模型训练和测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_4 (InputLayer)         (None, None)              0         \n",
      "_________________________________________________________________\n",
      "embedding_4 (Embedding)      (None, None, 512)         1992704   \n",
      "_________________________________________________________________\n",
      "lstm_7 (LSTM)                (None, None, 512)         2099200   \n",
      "_________________________________________________________________\n",
      "lstm_8 (LSTM)                (None, None, 512)         2099200   \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, None, 3892)        1996596   \n",
      "=================================================================\n",
      "Total params: 8,187,700\n",
      "Trainable params: 8,187,700\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Epoch 1/1\n",
      "2/2 [==============================] - 4s 2s/step - loss: 17.3067 - acc: 0.0000e+00\n",
      "稚，。。。，，的。，的。，的，的的。，，的的。，的，的的。，，的的。，的，的的。，，的的。，的，的的。，，的的。，的，的的。，，的的。，的，的的。，，的的。，的，的的。，，的的。，的，的的。，，的的。，\n"
     ]
    }
   ],
   "source": [
    "data_batch = data_generator(numdata, BATCH_SIZE, TIME_STEPS)\n",
    "novel = RNNModel(BATCH_SIZE, HIDDEN_SIZE, HIDDEN_LAYERS, VOCAB_SIZE)\n",
    "for i in range(BATCH_NUMS):\n",
    "    x, y = next(data_batch)\n",
    "    y = onehot(y)\n",
    "    novel.train(x, y)\n",
    "\n",
    "x_initial = np.zeros((1,1), dtype=int) + 8\n",
    "novel.test(x_initial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
